#include<iostream>
using namespace std;
//隐式类型转化 单参构造函数
//可以使用explicit修饰构造函数
//禁止隐式类型转化
/* class Date
{
    public:
    Date(int year)
     :_year(year)
    {

    }
    int Getyear()
    {
        return _year;
    }
    private:
 int _year;
 int _month;
 int _day;

}; */
//多参数 隐式类型转化 c11支持
//2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转换作用
class Date
{
    public:
    Date(int year,int month,int day)
     :_year(year)
     ,_month(month)
     ,_day(day)
    {

    }
   void Printdate()
   {
    cout<<_year<<"\\"<<_month<<"\\"<<_day<<endl;
   }
   int Getyear()
   {
    return _year;
   }
    private:
 int _year;
 int _month;
 int _day;

}; 
/* void test1()
{
    Date d1=10;
    cout<<d1.Getyear();
   } */
   void test2()
   {
    Date d1={2022,10,22};
    d1.Printdate();
   } 
//静态成员变量
//统计一下总共创建了多少类
class A
{
    public:
   A(int a)
   :_a(a)
   {
     _cnt++;
   }
   A(const A& a)
   :_a(a._a)
   {
_cnt++;
   }
   //静态成员函数，没有this指针，并且只能访问静态成员变量
  static int Getcnt()
  {
    return _cnt;
  }
    private:
    int _a;
    static int _cnt;//(声明)
};
//生命周期是全局的，作用域是受限制的
int A::_cnt=0;//定义初始化
//测试静态成员变量
void test()
{
    A aa1(10);
    A aa2(aa1);
    A aa3=110;
   cout<<A::Getcnt()<<endl;
}
//要求让类只能在栈上
class B
{
public:
//如果不加static会导致因果失衡，无法判断是先有构造函数，还是先有类
//所以加上static修饰后 取消this指针
      static B Getobjb(int b)
      {
          return B(b);
      }
void Print()
{
    cout<<_b<<endl;
}
    private :
    int _b;
    B(int b)
    :_b(b)
    {

    }
};
void testb()
{
    B ret=B::Getobjb(10);
    ret.Print();
}
int main()
{
 
   //  test();
  // test2();
  testb();
    return 0;
}
